window.exports = {
    json_pre: {
        mode: "none", // 无 UI 插件
        args: {
            enter: async (action) => {
                const { clipboard } = require('electron')
                const input = clipboard.readText(); // 获取剪切板内容
                // utools.showNotification("剪切板内容: " + input); // 显示剪切板内容
                try {
                    // Step 1: 预处理输入
                    let preprocessed = input
                        // 先处理字符串中的换行
                        .replace(/"[^"\\]*(?:\\.[^"\\]*)*"/g, match => 
                            match.replace(/\r\n|\r|\n/g, '')
                        )
                        // 处理注释和其他换行
                        .replace(/:\/\//g, "=-_-=") // 处理 URL 中的冒号和斜杠, 包括[https://], [ftp://], [mailto://] 等场景  
                        .replace(/(^|[^"'])\/\/.*$/gm, '')  // 删除单行注释
                        .replace(/(^|[^"'])\/\*[\s\S]*?\*\//g, '') // 删除多行注释
                        .replace(/=-_-=/g, "://") // 恢复 URL 中的冒号和斜杠
                        .replace(/\bnan\b/gi, "null")// 替换 NAN 为 null
                        .replace(/\bundefined\b/gi, "null")
                        .replace(/\bInfinity\b/g, "null"); 
                    
                    // 处理单引号字符串及其包裹的双引号
                    validJson = processQuotes(preprocessed);
                    
                    // Step 2: BSON 转 JSON
                    validJson = bsonToJson(validJson);
                    validJson = pythonToJson(validJson); 
                    
                    clipboard.writeText(validJson); // 复制到剪切板
                    // utools.showNotification("转换后的 JSON 已复制到剪切板");
                    // JSON.parse(validJson); // 验证合法性
                    // Step 3: 输出到 JSON 编辑器
                    setTimeout(() => {
                        utools.redirect(["JSON 编辑器", "Json"], {
                            type: "text",
                            data: validJson
                        });
                    }, 500); // 增加缓冲时间

                    // Step 4: 隐藏当前插件窗口
                    utools.outPlugin();
                } catch (err) {
                    utools.showNotification("转换失败，错误信息已复制到剪切板\n" + err.message);
                    clipboard.writeText(err.message); // 错误消息复制到剪切板
                }
            },
        },
    },
};

// 处理单引号字符串中的双引号
function processQuotes(str) {
    // 保护已转义的双引号
    str = str.replace(/\\"/g, '<<ESCAPED_QUOTE>>');
    
    // 处理单引号字符串中的双引号
    str = str.replace(/\'([^\']*)'/g, (match, content) => {
        // 转义未转义的双引号，并将单引号替换为双引号
        return '"' + content.replace(/(?<!\\)"/g, '\\"') + '"';
    });
    
    // 恢复已转义的双引号
    return str.replace(/<<ESCAPED_QUOTE>>/g, '\\"');
}


// 通用的 Python 转 JSON 函数
function pythonToJson(pythonStr) {
    // 处理 Python 的 True、False 和 None
    pythonStr = pythonStr.replace(/\bTrue\b/g, "true")
                         .replace(/\bFalse\b/g, "false")
                         .replace(/\bNone\b/g, "null");

    // 处理函数调用格式
    return pythonStr.replace(/([a-zA-Z_]\w*)\(((?:[^()]*|\([^()]*\))*)\)/g, (match, func, content) => {
        if (content.includes('=')) {
            let processedContent = splitArguments(content).map(pair => {
                if (!pair.trim()) return null;
                
                // 更精准的键值对拆分（支持带括号的值）
                const [key, ...valueParts] = pair.split(/=(?=(?:[^']*'[^']*')*[^']*$)/);
                const value = valueParts.join('=').trim();

                // 处理嵌套函数调用
                if (/^[a-zA-Z_]\w*\(/.test(value)) {
                    return `"${key}":${pythonToJson(value)}`;
                }

                return `"${key}":${value}`;
            }).filter(Boolean).join(',');

            return `{"$type":"${func}",${processedContent}}`;
        }
        return match;
    });
}

// 精准拆分函数参数的工具函数
function splitArguments(content) {
    const args = [];
    let nestedLevel = 0;
    let currentArg = '';
    let inString = false;
    let stringQuote = '';
    
    for (let i = 0; i < content.length; i++) {
        const char = content[i];

        // 处理字符串中的内容
        if (inString) {
            currentArg += char;
            // 检测字符串结束
            if (char === stringQuote && content[i-1] !== '\\') {
                inString = false;
            }
            continue;
        }

        // 检测字符串开始
        if (['"', "'"].includes(char)) {
            inString = true;
            stringQuote = char;
            currentArg += char;
            continue;
        }

        if (char === ',' && nestedLevel === 0) {
            args.push(currentArg.trim());
            currentArg = '';
        } else {
            if (char === '(') nestedLevel++;
            if (char === ')') nestedLevel--;
            currentArg += char;
        }
    }

    if (currentArg.trim()) {
        args.push(currentArg.trim());
    }

    return args.filter(arg => arg !== '');
}

// BSON JSON 转合法 JSON 的函数
function bsonToJson(bsonStr) {
    // // 处理BinData类型
    bsonStr = bsonStr.replace(/BinData\((\d+),\s*"((?:[^"]|\\"|\\\\)*?)"\)/g, (_, subType, base64Str) => {
        try {
            const decoded = Buffer.from(base64Str, 'base64').toString('utf8');
            try {
                const jsonObj = JSON.parse(decoded);
                return JSON.stringify(jsonObj);
            } catch {
                return `"${decoded.replace(/"/g, '\\"')}"`;  // 确保字符串中的双引号被正确转义
            }
        } catch {
            // 如果解码失败，保持原始格式
            return `{"$type":"BinData","subType":${subType},"base64":"${base64Str}"}`;
        }
    });

    // 处理Timestamp类型
    bsonStr = bsonStr.replace(/Timestamp\((\d+),\s*(\d+)\)/g, (_, seconds, increment) => {
        const date = new Date(seconds * 1000);
        return `"${date.toISOString()}"`;
    });

    // 处理正则表达式（包括字面量形式）
    bsonStr = bsonStr.replace(/RegExp\("([^"]+)"(?:,\s*"([^"]+)")?\)/g, (_, pattern, flags) => {
        return `{"$regex":"${pattern}","$options":"${flags || ''}"}`;
    }).replace(/\/([^\/]+)\/([gimsuy]*)/g, (_, pattern, flags) => {
        return `{"$regex":"${pattern}","$options":"${flags}"}`;
    });

    // 处理ISODate类型
    bsonStr = bsonStr.replace(/ISODate\("([^"]+)"\)/g, (_, dateStr) => {
        return `"${dateStr}"`;
    });
    // 处理Code类型
    // 第一步：将所有function定义替换为占位符
    const functionPlaceholder = '<<FUNCTION_PLACEHOLDER>>';
    bsonStr = bsonStr.replace("function()", functionPlaceholder);
    // 第二步：精确匹配Code函数调用
    bsonStr = bsonStr.replace(/Code\(\s*"((?:[^"]|\\")*?)"\s*(?:,\s*([\s\S]*?))?\s*\)/g, (match, code, scope) => {
        try {
            // 第三步：构建JSON结果
            let result = {"$code": code.trim()};
            
            if (scope) {
                // 处理作用域对象
                let scopeStr = scope.trim();
                // 确保对象的key都有引号
                scopeStr = scopeStr.replace(/([{,]\s*)([a-zA-Z_]\w*)\s*:/g, '$1"$2":');
                try {
                    result["$scope"] = JSON.parse(scopeStr);
                } catch (scopeErr) {
                    // 如果解析失败，保留原始字符串
                    result["$scope"] = scopeStr;
                }
            }
            else {
                return JSON.stringify({
                    "$code": code.trim()
                });
            }
            
            return JSON.stringify(result);
        } catch (err) {
            utools.showNotification("Code类型转换失败：" + err.message);
            return match;  // 解析失败保持原样
        }
    });

    // 第四步：恢复function占位符
    bsonStr = bsonStr.replace(functionPlaceholder, "function()");
    // 处理独立的匿名函数
    bsonStr = bsonStr.replace(/(?<!["'])function\s*\([^)]*\)\s*\{[\s\S]*?\}(?!["'])/g, (match) => {
        return JSON.stringify({
            "$code": match.trim()
        });
    });
    // 处理MinKey和MaxKey类型
    bsonStr = bsonStr.replace(/MinKey\(([^)]*)\)/g, (_, args) => {
        return `{"$minKey": 1}`;
    }).replace(/MaxKey\(([^)]*)\)/g, (_, args) => {
        return `{"$maxKey": 1}`;
    });

    // 处理其他所有类型（直接提取括号内的内容）
    bsonStr = bsonStr.replace(/([a-zA-Z_]\w*)\(([^()]+)\)/g, (match, func, content) => {      
        // 如果内容包含逗号，将其转换为数组格式
        if (content.includes(',')) {
            const args = content.split(',').map(arg => arg.trim());
            return `{"$type":"${func}","args":[${args.join(',')}]}`;
        }
        
        // 对于简单类型，直接返回括号内的内容
        return content.trim();
    });

    return bsonStr;
}